JavaScript இன் Async Iterators ஆனது ஸ்ட்ரீம் செயலாக்கத்திற்கான ஒரு சக்திவாய்ந்த செயல்திறன் எஞ்சினாக எவ்வாறு செயல்படுகிறது, மேலும் உலகளாவிய பயன்பாடுகளில் தரவு ஓட்டம், நினைவகப் பயன்பாடு மற்றும் பதிலளிப்புத்திறனை எவ்வாறு மேம்படுத்துகிறது என்பதை ஆராயுங்கள்.
JavaScript Async Iterator செயல்திறன் எஞ்சினை கட்டவிழ்த்து விடுதல்: உலகளாவிய அளவிலான ஸ்ட்ரீம் செயலாக்க மேம்படுத்தல்
இன்றைய ஒன்றோடொன்று இணைக்கப்பட்ட உலகில், பயன்பாடுகள் தொடர்ந்து பரந்த அளவிலான தரவுகளைக் கையாள்கின்றன. தொலைநிலை IoT சாதனங்களிலிருந்து நிகழ்நேர சென்சார் அளவீடுகள் முதல் பெரிய நிதி பரிவர்த்தனை பதிவுகள் வரை, திறமையான தரவு செயலாக்கம் மிக முக்கியமானது. பாரம்பரிய அணுகுமுறைகள் பெரும்பாலும் வள மேலாண்மையில் போராடுகின்றன, இது தொடர்ச்சியான, வரம்பற்ற தரவு ஸ்ட்ரீம்களை எதிர்கொள்ளும் போது நினைவக சோர்வு அல்லது மந்தமான செயல்திறனுக்கு வழிவகுக்கிறது. இங்கேயுள்ள JavaScript இன் ஒத்திசைவற்ற Iterators ஆனது ஒரு சக்திவாய்ந்த 'செயல்திறன் எஞ்சினாக' வெளிப்பட்டு, பல்வேறு, உலகளாவிய அளவில் விநியோகிக்கப்பட்ட அமைப்புகளில் ஸ்ட்ரீம் செயலாக்கத்தை மேம்படுத்துவதற்கான ஒரு அதிநவீன மற்றும் நேர்த்தியான தீர்வை வழங்குகிறது.
இந்த விரிவான வழிகாட்டி, வலுவான, அளவிடக்கூடிய மற்றும் நினைவக-திறமையான தரவு குழாய்களை உருவாக்குவதற்கான ஒரு அடிப்படைக் கட்டமைப்பை async iterators எவ்வாறு வழங்குகிறது என்பதை ஆராய்கிறது. அவற்றின் முக்கிய கொள்கைகள், நடைமுறைப் பயன்பாடுகள் மற்றும் மேம்பட்ட மேம்படுத்தல் நுட்பங்கள் ஆகியவற்றை, உலகளாவிய தாக்கம் மற்றும் நிஜ உலக சூழ்நிலைகளின் கண்ணோட்டத்தில் ஆராய்வோம்.
அடிப்படையைப் புரிந்துகொள்ளுதல்: ஒத்திசைவற்ற Iterators என்றால் என்ன?
செயல்திறனை ஆராய்வதற்கு முன், ஒத்திசைவற்ற iterators என்றால் என்ன என்பதைத் தெளிவாகப் புரிந்துகொள்வோம். ECMAScript 2018 இல் அறிமுகப்படுத்தப்பட்ட அவை, ஒத்திசைவற்ற தரவு மூலங்களைக் கையாள, பழக்கமான ஒத்திசைவான மறு செய்கை வடிவத்தை (for...of சுழல்கள் போன்றவை) நீட்டிக்கின்றன.
Symbol.asyncIterator மற்றும் for await...of
ஒரு பொருள், Symbol.asyncIterator வழியாக அணுகக்கூடிய ஒரு முறையைக் கொண்டிருந்தால், அது ஒத்திசைவற்ற இட்டரேபிள் (iterable) என்று கருதப்படுகிறது. இந்த முறை அழைக்கப்படும் போது, ஒரு ஒத்திசைவற்ற iteratorஐத் தருகிறது. ஒரு ஒத்திசைவற்ற iterator என்பது, next() முறையைக் கொண்ட ஒரு பொருள் ஆகும், இது ஒரு Promiseஐத் திருப்பித் தருகிறது, அது { value: any, done: boolean } வடிவத்தில் உள்ள ஒரு பொருளாகத் தீர்க்கப்படுகிறது, இது ஒத்திசைவான iterators போன்றது, ஆனால் ஒரு Promise இல் உள்ளடக்கப்பட்டுள்ளது.
for await...of சுழற்சியுடன் மாயாஜாலம் நடக்கிறது. இந்த அமைப்பு, ஒத்திசைவற்ற இட்டரேபிள்களின் மீது மறுசெய்கை செய்ய உங்களை அனுமதிக்கிறது, ஒவ்வொரு அடுத்த மதிப்பும் தயாராகும் வரை செயலாக்கத்தை நிறுத்தி, ஸ்ட்ரீமில் உள்ள அடுத்த தரவுத் துண்டிற்காக திறம்பட 'காத்திருக்கிறது'. இந்தத் தடையற்ற தன்மை I/O-சார்ந்த செயல்பாடுகளில் செயல்திறனுக்கு முக்கியமானதாகும்.
async function* generateAsyncSequence() {
yield await Promise.resolve(1);
yield await Promise.resolve(2);
yield await Promise.resolve(3);
}
async function consumeSequence() {
for await (const num of generateAsyncSequence()) {
console.log(num);
}
console.log("Async sequence complete.");
}
// To run:
// consumeSequence();
இங்கே, generateAsyncSequence என்பது ஒரு ஒத்திசைவற்ற ஜெனரேட்டர் செயல்பாடு ஆகும், இது இயல்பாகவே ஒரு ஒத்திசைவற்ற இட்டரேபிளைத் திருப்பித் தருகிறது. for await...of சுழற்சி பின்னர் அதன் மதிப்புகள் ஒத்திசைவற்ற முறையில் கிடைக்கும்போது அவற்றை நுகர்கிறது.
"செயல்திறன் எஞ்சின்" உருவகம்: Async Iterators எவ்வாறு செயல்திறனை இயக்குகின்றன
வளங்களின் தொடர்ச்சியான ஓட்டத்தைச் செயலாக்க வடிவமைக்கப்பட்ட ஒரு அதிநவீன எஞ்சினை கற்பனை செய்து பாருங்கள். அது எல்லாவற்றையும் ஒரே நேரத்தில் விழுங்குவதில்லை; மாறாக, அது வளங்களை திறமையாக, தேவைக்கேற்ப, மற்றும் அதன் உள்ளெடுப்பு வேகத்தின் மீது துல்லியமான கட்டுப்பாட்டுடன் பயன்படுத்துகிறது. JavaScript இன் async iterators இதேபோல் செயல்படுகின்றன, தரவு ஸ்ட்ரீம்களுக்கான இந்த அறிவார்ந்த 'செயல்திறன் எஞ்சினாக' செயல்படுகின்றன.
- கட்டுப்படுத்தப்பட்ட வள உள்ளெடுப்பு:
for await...ofசுழல் ஒரு த்ராட்டலாக செயல்படுகிறது. இது தரவைச் செயலாக்கத் தயாராக இருக்கும்போது மட்டுமே இழுக்கிறது, மேலும் கணினியை மிக விரைவாக அதிக தரவுகளால் மூழ்கடிப்பதைத் தடுக்கிறது. - தடையற்ற செயல்பாடு: அடுத்த தரவுத் துண்டிற்காக காத்திருக்கும் போது, JavaScript நிகழ்வு சுழல் மற்ற பணிகளைக் கையாள சுதந்திரமாக இருக்கும், இது பயன்பாடு பதிலளிக்கக்கூடியதாக இருப்பதை உறுதி செய்கிறது, இது பயனர் அனுபவத்திற்கும் சேவையக நிலைத்தன்மைக்கும் முக்கியமானது.
- நினைவகப் பயன்பாட்டு மேம்படுத்தல்: முழு தரவுத்தொகுப்பையும் நினைவகத்தில் ஏற்றுவதற்குப் பதிலாக, தரவு படிப்படியாக, துண்டு துண்டாகச் செயலாக்கப்படுகிறது. பெரிய கோப்புகள் அல்லது வரம்பற்ற ஸ்ட்ரீம்களைக் கையாள இது ஒரு கேம்-சேஞ்சர்.
- மீள்தன்மை மற்றும் பிழை கையாளுதல்: தொடர்ச்சியான, வாக்குறுதி அடிப்படையிலான தன்மை, ஸ்ட்ரீமிற்குள் வலுவான பிழை பரவல் மற்றும் கையாளுதலை அனுமதிக்கிறது, இது இணக்கமான மீட்பு அல்லது பணிநிறுத்தத்தை செயல்படுத்துகிறது.
இந்த எஞ்சின், டெவலப்பர்கள் பல்வேறு உலகளாவிய மூலங்களிலிருந்து தரவுகளை, அவற்றின் தாமதம் அல்லது அளவு பண்புகள் பொருட்படுத்தாமல், தடையின்றி கையாளக்கூடிய வலுவான அமைப்புகளை உருவாக்க அனுமதிக்கிறது.
உலகளாவிய சூழலில் ஸ்ட்ரீம் செயலாக்கம் ஏன் முக்கியமானது
தரவு எண்ணற்ற மூலங்களிலிருந்து உருவாகி, பல்வேறு நெட்வொர்க்குகள் வழியாகப் பயணிக்கக்கூடிய மற்றும் நம்பத்தகுந்த முறையில் செயலாக்கப்பட வேண்டிய உலகளாவிய சூழலில், திறமையான ஸ்ட்ரீம் செயலாக்கத்தின் தேவை அதிகரிக்கிறது.
- IoT மற்றும் சென்சார் நெட்வொர்க்குகள்: ஜெர்மனியில் உள்ள உற்பத்தி ஆலைகள், பிரேசிலில் உள்ள விவசாய வயல்கள் மற்றும் ஆஸ்திரேலியாவில் உள்ள சுற்றுச்சூழல் கண்காணிப்பு நிலையங்கள் முழுவதும் மில்லியன் கணக்கான ஸ்மார்ட் சென்சார்கள் தொடர்ந்து தரவுகளை அனுப்புவதை கற்பனை செய்து பாருங்கள். Async iterators இந்த உள்வரும் தரவு ஸ்ட்ரீம்களை நினைவகத்தை நிரப்பாமல் அல்லது முக்கியமான செயல்பாடுகளைத் தடுக்காமல் செயலாக்க முடியும்.
- நிகழ்நேர நிதி பரிவர்த்தனைகள்: வங்கிகள் மற்றும் நிதி நிறுவனங்கள் தினமும் பில்லியன் கணக்கான பரிவர்த்தனைகளைச் செயலாக்குகின்றன, அவை பல்வேறு நேர மண்டலங்களிலிருந்து உருவாகின்றன. ஒரு ஒத்திசைவற்ற ஸ்ட்ரீம் செயலாக்க அணுகுமுறை, பரிவர்த்தனைகள் சரிபார்க்கப்பட்டு, பதிவு செய்யப்பட்டு, திறமையாக சமரசம் செய்யப்படுவதை உறுதி செய்கிறது, இது அதிக அலைவரிசை மற்றும் குறைந்த தாமதத்தை பராமரிக்கிறது.
- பெரிய கோப்பு பதிவேற்றங்கள்/பதிவிறக்கங்கள்: உலகெங்கிலும் உள்ள பயனர்கள் பெரிய மீடியா கோப்புகள், அறிவியல் தரவுத்தொகுப்புகள் அல்லது காப்புப் பிரதிகளைப் பதிவேற்றுகின்றனர் மற்றும் பதிவிறக்குகின்றனர். Async iterators உடன் இந்த கோப்புகளை துண்டு துண்டாக செயலாக்குவது சேவையக நினைவக சோர்வைத் தடுக்கிறது மற்றும் முன்னேற்றத்தைக் கண்காணிக்க அனுமதிக்கிறது.
- API Pagination மற்றும் தரவு ஒத்திசைவு: பக்கமிடப்பட்ட APIகளைப் பயன்படுத்தும் போது (எ.கா., உலகளாவிய வானிலை சேவையிலிருந்து வரலாற்று வானிலை தரவை மீட்டெடுத்தல் அல்லது ஒரு சமூக தளத்திலிருந்து பயனர் தரவை மீட்டெடுத்தல்), முந்தைய பக்கம் செயலாக்கப்பட்ட பின்னரே அடுத்த பக்கங்களை மீட்டெடுப்பதை async iterators எளிதாக்குகின்றன, இது தரவு நிலைத்தன்மையை உறுதி செய்கிறது மற்றும் நெட்வொர்க் சுமையைக் குறைக்கிறது.
- தரவு குழாய்கள் (ETL): பகுப்பாய்விற்காக வெவ்வேறு தரவுத்தளங்கள் அல்லது தரவு ஏரிகளிலிருந்து பெரிய தரவுத்தொகுப்புகளை பிரித்தெடுத்தல், மாற்றுதல் மற்றும் ஏற்றுதல் (ETL) பெரும்பாலும் பெரிய தரவு நகர்வுகளை உள்ளடக்கியது. Async iterators இந்த குழாய்களை படிப்படியாக செயலாக்க உதவுகிறது, வெவ்வேறு புவியியல் தரவு மையங்கள் முழுவதும் கூட.
இந்தச் சூழ்நிலைகளை இணக்கமாகக் கையாளும் திறன் என்பது, தரவின் ஆதாரம் அல்லது அளவு எதுவாக இருந்தாலும், உலகளவில் பயனர்கள் மற்றும் அமைப்புகளுக்கு பயன்பாடுகள் செயல்திறன் மிக்கதாகவும், கிடைக்கக்கூடியதாகவும் இருக்கும் என்பதைக் குறிக்கிறது.
Async Iterators உடன் முக்கிய மேம்படுத்தல் கொள்கைகள்
ஒரு செயல்திறன் எஞ்சினாக async iterators இன் உண்மையான சக்தி, அவை இயல்பாகவே செயல்படுத்தும் அல்லது எளிதாக்கும் பல அடிப்படைக் கொள்கைகளில் உள்ளது.
1. சோம்பேறி மதிப்பீடு: தேவைக்கேற்ப தரவு
iterators இன் மிக முக்கியமான செயல்திறன் நன்மைகளில் ஒன்று, ஒத்திசைவான மற்றும் ஒத்திசைவற்ற இரண்டும், சோம்பேறி மதிப்பீடு ஆகும். நுகர்வோரால் வெளிப்படையாகக் கோரப்படும் வரை தரவு உருவாக்கப்படவோ அல்லது எடுக்கப்படவோ இல்லை. இதன் பொருள்:
- குறைக்கப்பட்ட நினைவகப் பயன்பாடு: ஒரு முழு தரவுத்தொகுப்பையும் நினைவகத்தில் ஏற்றுவதற்குப் பதிலாக (இது ஜிகாபைட்டுகள் அல்லது டெராபைட்டுகளாக இருக்கலாம்), செயலாக்கப்படும் தற்போதைய துண்டு மட்டுமே நினைவகத்தில் இருக்கும்.
- வேகமான தொடக்க நேரங்கள்: முதல் சில உருப்படிகள் கிட்டத்தட்ட உடனடியாக செயலாக்கப்படலாம், முழு ஸ்ட்ரீம் தயாராகும் வரை காத்திருக்க வேண்டியதில்லை.
- திறமையான வளப் பயன்பாடு: ஒரு நுகர்வோருக்கு மிக நீண்ட ஸ்ட்ரீமில் இருந்து ஒரு சில உருப்படிகள் மட்டுமே தேவைப்பட்டால், தயாரிப்பாளர் முன்னதாகவே நிறுத்தலாம், இது கணக்கீட்டு வளங்களையும் நெட்வொர்க் அலைவரிசையையும் சேமிக்கிறது.
ஒரு சர்வர் கிளஸ்டரிலிருந்து ஒரு லாக் கோப்பை நீங்கள் செயலாக்கும் ஒரு சூழ்நிலையைக் கவனியுங்கள். சோம்பேறி மதிப்பீட்டின் மூலம், நீங்கள் முழு லாகையும் ஏற்றுவதில்லை; நீங்கள் ஒரு வரியைப் படித்து, அதைச் செயலாக்கி, பின்னர் அடுத்ததைப் படிக்கிறீர்கள். நீங்கள் தேடும் பிழையை முன்னதாகவே கண்டறிந்தால், நீங்கள் நிறுத்தலாம், கணிசமான செயலாக்க நேரம் மற்றும் நினைவகத்தைச் சேமிக்கலாம்.
2. பின் அழுத்தம் கையாளுதல்: அதிகப்படியான சுமைகளைத் தடுத்தல்
பின் அழுத்தம் என்பது ஸ்ட்ரீம் செயலாக்கத்தில் ஒரு முக்கியமான கருத்து. இது ஒரு நுகர்வோர், ஒரு தயாரிப்பாளருக்கு தரவை மிக மெதுவாகச் செயலாக்குகிறார் என்றும், தயாரிப்பாளர் வேகத்தைக் குறைக்க வேண்டும் என்றும் சமிக்ஞை செய்யும் திறன் ஆகும். பின் அழுத்தம் இல்லாமல், ஒரு வேகமான தயாரிப்பாளர் ஒரு மெதுவான நுகர்வோரை மூழ்கடிக்க முடியும், இது பஃபர் நிரம்பி வழிதல், தாமதம் அதிகரித்தல் மற்றும் சாத்தியமான பயன்பாட்டு செயலிழப்புகளுக்கு வழிவகுக்கும்.
for await...of சுழற்சி இயல்பாகவே பின் அழுத்தத்தை வழங்குகிறது. சுழற்சி ஒரு உருப்படியைச் செயலாக்கி, பின்னர் ஒரு await ஐ எதிர்கொள்ளும் போது, அந்த await தீர்க்கப்படும் வரை ஸ்ட்ரீமின் நுகர்வை நிறுத்தி வைக்கிறது. தயாரிப்பாளர் (async iterator இன் next() முறை) தற்போதைய உருப்படி முழுமையாகச் செயலாக்கப்பட்டு, நுகர்வோர் அடுத்ததற்குத் தயாரானவுடன் மட்டுமே மீண்டும் அழைக்கப்படுவார்.
இந்த மறைமுகமான பின் அழுத்தக் கருவி, ஸ்ட்ரீம் நிர்வாகத்தை கணிசமாக எளிதாக்குகிறது, குறிப்பாக அதிக மாறுபாடுள்ள நெட்வொர்க் நிலைமைகளில் அல்லது வெவ்வேறு தாமதங்களைக் கொண்ட உலகளாவிய பல்வேறு மூலங்களிலிருந்து தரவுகளைச் செயலாக்கும் போது. இது ஒரு நிலையான மற்றும் கணிக்கக்கூடிய ஓட்டத்தை உறுதி செய்கிறது, தயாரிப்பாளர் மற்றும் நுகர்வோர் இருவரையும் வள சோர்விலிருந்து பாதுகாக்கிறது.
3. இணக்கம் vs. இணைகோடி: உகந்த பணி அட்டவணைப்படுத்துதல்
JavaScript அடிப்படையில் ஒற்றை நூல் கொண்டது (உலாவி முக்கிய நூல் மற்றும் Node.js நிகழ்வு சுழலில்). Async iterators இணக்கத்தன்மையை (concurrency) பயன்படுத்துகின்றன, உண்மையான இணைகோடியை அல்ல (Web Workers அல்லது worker threads ஐப் பயன்படுத்தாத வரை), பதிலளிப்புத்தன்மையை பராமரிக்க. ஒரு await முக்கிய வார்த்தை தற்போதைய ஒத்திசைவற்ற செயல்பாட்டின் செயலாக்கத்தை இடைநிறுத்தும்போது, அது முழு JavaScript நிகழ்வு சுழலையும் தடுப்பதில்லை. இது பயனர் உள்ளீடு, நெட்வொர்க் கோரிக்கைகள் அல்லது பிற ஸ்ட்ரீம் செயலாக்கம் போன்ற பிற நிலுவையில் உள்ள பணிகளைத் தொடர அனுமதிக்கிறது.
இதன் பொருள், ஒரு பெரிய தரவு ஸ்ட்ரீமைச் செயலாக்கும் போதும் உங்கள் பயன்பாடு பதிலளிக்கக்கூடியதாக இருக்கும். எடுத்துக்காட்டாக, ஒரு இணையப் பயன்பாடு ஒரு பெரிய வீடியோ கோப்பைத் துண்டு துண்டாகப் பதிவிறக்கிச் செயலாக்கும்போது (ஒரு async iterator ஐப் பயன்படுத்தி), உலாவியை உறைய வைக்காமல் பயனரை UI உடன் தொடர்பு கொள்ள ஒரே நேரத்தில் அனுமதிக்க முடியும். இது ஒரு மென்மையான பயனர் அனுபவத்தை சர்வதேச பார்வையாளர்களுக்கு வழங்குவதற்கு மிகவும் முக்கியமானது, அவர்களில் பலர் குறைவான சக்திவாய்ந்த சாதனங்களில் அல்லது மெதுவான நெட்வொர்க் இணைப்புகளில் இருக்கலாம்.
4. வள மேலாண்மை: இணக்கமான பணிநிறுத்தம்
Async iterators சரியான வள சுத்திகரிப்புக்கான ஒரு பொறிமுறையையும் வழங்குகின்றன. ஒரு async iterator பகுதியளவில் பயன்படுத்தப்பட்டால் (எ.கா., சுழற்சி முன்கூட்டியே நிறுத்தப்பட்டால் அல்லது ஒரு பிழை ஏற்பட்டால்), JavaScript ரன்டைம் ஆனது iterator இன் விருப்பமான return() முறையை அழைக்க முயற்சிக்கும். இந்த முறை, கோப்பு கைப்பிடிகள், தரவுத்தள இணைப்புகள் அல்லது நெட்வொர்க் சாக்கெட்டுகள் போன்ற தேவையான சுத்திகரிப்பு பணிகளை iterator செய்ய அனுமதிக்கிறது.
இதேபோல், ஒரு விருப்பமான throw() முறை, ஒரு பிழையை iterator இல் செலுத்தப் பயன்படுத்தப்படலாம், இது நுகர்வோர் பக்கத்திலிருந்து தயாரிப்பாளருக்கு சிக்கல்களை சமிக்ஞை செய்வதற்கு பயனுள்ளதாக இருக்கும்.
இந்த வலுவான வள மேலாண்மை, சிக்கலான, நீண்டகால ஸ்ட்ரீம் செயலாக்க சூழ்நிலைகளில் கூட – சர்வர்-பக்க பயன்பாடுகள் அல்லது IoT நுழைவாயில்களில் பொதுவானது – வளங்கள் கசியாமல் இருப்பதை உறுதி செய்கிறது, கணினி நிலைத்தன்மையை மேம்படுத்துகிறது மற்றும் காலப்போக்கில் செயல்திறன் குறைபாட்டைத் தடுக்கிறது.
நடைமுறைச் செயலாக்கங்கள் மற்றும் எடுத்துக்காட்டுகள்
async iterators எவ்வாறு நடைமுறை, மேம்படுத்தப்பட்ட ஸ்ட்ரீம் செயலாக்க தீர்வுகளாக மாறுகின்றன என்பதைப் பார்ப்போம்.
1. பெரிய கோப்புகளை திறமையாகப் படித்தல் (Node.js)
Node.js இன் fs.createReadStream() ஒரு படிக்கக்கூடிய ஸ்ட்ரீமைத் திருப்பித் தருகிறது, இது ஒரு ஒத்திசைவற்ற இட்டரேபிள் ஆகும். இது பெரிய கோப்புகளை நம்பமுடியாத அளவிற்கு எளிமையாகவும் நினைவக-திறமையாகவும் செயலாக்குகிறது.
const fs = require('fs');
const path = require('path');
async function processLargeLogFile(filePath) {
const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
let lineCount = 0;
let errorCount = 0;
console.log(`Starting to process file: ${filePath}`);
try {
for await (const chunk of stream) {
// In a real scenario, you'd buffer incomplete lines
// For simplicity, we'll assume chunks are lines or contain multiple lines
const lines = chunk.split('\n');
for (const line of lines) {
if (line.includes('ERROR')) {
errorCount++;
console.warn(`Found ERROR: ${line.trim()}`);
}
lineCount++;
}
}
console.log(`\nProcessing complete for ${filePath}.`)
console.log(`Total lines processed: ${lineCount}`);
console.log(`Total errors found: ${errorCount}`);
} catch (error) {
console.error(`Error processing file: ${error.message}`);
}
}
// Example usage (ensure you have a large 'app.log' file):
// const logFilePath = path.join(__dirname, 'app.log');
// processLargeLogFile(logFilePath);
இந்த எடுத்துக்காட்டு, ஒரு பெரிய லாக் கோப்பை அதன் முழுமையையும் நினைவகத்தில் ஏற்றாமல் செயலாக்குவதைக் காட்டுகிறது. ஒவ்வொரு chunk உம் கிடைக்கும்போது செயலாக்கப்படுகிறது, இது RAM இல் பொருந்தாத அளவுக்கு பெரிய கோப்புகளுக்கு ஏற்றதாக அமைகிறது, இது உலகளாவிய தரவு பகுப்பாய்வு அல்லது காப்பக அமைப்புகளில் பொதுவான ஒரு சவால் ஆகும்.
2. API பதில்களை ஒத்திசைவற்ற முறையில் பக்கமிடுதல்
பல APIகள், குறிப்பாக பெரிய தரவுத்தொகுப்புகளை வழங்கும் APIகள், பக்கமிடுதலைப் பயன்படுத்துகின்றன. ஒரு async iterator அடுத்தடுத்த பக்கங்களை தானாகவே பெறுவதை நேர்த்தியாகக் கையாள முடியும்.
async function* fetchAllPages(baseUrl, initialParams = {}) {
let currentPage = 1;
let hasMore = true;
while (hasMore) {
const params = new URLSearchParams({ ...initialParams, page: currentPage });
const url = `${baseUrl}?${params.toString()}`;
console.log(`Fetching page ${currentPage} from ${url}`);
const response = await fetch(url);
if (!response.ok) {
throw new Error(`API error: ${response.statusText}`);
}
const data = await response.json();
// Assume API returns 'items' and 'nextPage' or 'hasMore'
for (const item of data.items) {
yield item;
}
// Adjust these conditions based on your actual API's pagination scheme
if (data.nextPage) {
currentPage = data.nextPage;
} else if (data.hasOwnProperty('hasMore')) {
hasMore = data.hasMore;
currentPage++;
} else {
hasMore = false;
}
}
}
async function processGlobalUserData() {
// Imagine an API endpoint for user data from a global service
const apiEndpoint = "https://api.example.com/users";
const filterCountry = "IN"; // Example: users from India
try {
for await (const user of fetchAllPages(apiEndpoint, { country: filterCountry })) {
console.log(`Processing user ID: ${user.id}, Name: ${user.name}, Country: ${user.country}`);
// Perform data processing, e.g., aggregation, storage, or further API calls
await new Promise(resolve => setTimeout(resolve, 50)); // Simulate async processing
}
console.log("All global user data processed.");
} catch (error) {
console.error(`Failed to process user data: ${error.message}`);
}
}
// To run:
// processGlobalUserData();
இந்த சக்திவாய்ந்த முறை, பக்கமிடுதல் தர்க்கத்தை மறைத்து, நுகர்வோர் தொடர்ச்சியான பயனர்களின் ஸ்ட்ரீம் போலத் தோன்றுவதை எளிதாக மீண்டும் செய்ய அனுமதிக்கிறது. வெவ்வேறு வீத வரம்புகள் அல்லது தரவு அளவுகளைக் கொண்ட பல்வேறு உலகளாவிய APIகளுடன் ஒருங்கிணைக்கும் போது இது விலைமதிப்பற்றது, இது திறமையான மற்றும் இணக்கமான தரவு மீட்டெடுப்பை உறுதி செய்கிறது.
3. ஒரு தனிப்பயன் Async Iterator ஐ உருவாக்குதல்: ஒரு நிகழ்நேர தரவு ஊட்டல்
WebSockets இலிருந்து நிகழ்நேர நிகழ்வு ஊட்டங்கள் அல்லது ஒரு தனிப்பயன் செய்தியிடல் வரிசை போன்ற தனிப்பயன் தரவு மூலங்களை மாதிரியாக்க உங்கள் சொந்த async iterators ஐ உருவாக்கலாம்.
class WebSocketDataFeed {
constructor(url) {
this.url = url;
this.buffer = [];
this.waitingResolvers = [];
this.ws = null;
this.connect();
}
connect() {
this.ws = new WebSocket(this.url);
this.ws.onmessage = (event) => {
const data = JSON.parse(event.data);
if (this.waitingResolvers.length > 0) {
// If there's a consumer waiting, resolve immediately
const resolve = this.waitingResolvers.shift();
resolve({ value: data, done: false });
} else {
// Otherwise, buffer the data
this.buffer.push(data);
}
};
this.ws.onclose = () => {
// Signal completion or error to waiting consumers
while (this.waitingResolvers.length > 0) {
const resolve = this.waitingResolvers.shift();
resolve({ value: undefined, done: true }); // No more data
}
};
this.ws.onerror = (error) => {
console.error('WebSocket Error:', error);
// Propagate error to consumers if any are waiting
};
}
// Make this class an async iterable
[Symbol.asyncIterator]() {
return this;
}
// The core async iterator method
async next() {
if (this.buffer.length > 0) {
return { value: this.buffer.shift(), done: false };
} else if (this.ws && this.ws.readyState === WebSocket.CLOSED) {
return { value: undefined, done: true };
} else {
// No data in buffer, wait for the next message
return new Promise(resolve => this.waitingResolvers.push(resolve));
}
}
// Optional: Clean up resources if iteration stops early
async return() {
if (this.ws && this.ws.readyState === WebSocket.OPEN) {
console.log('Closing WebSocket connection.');
this.ws.close();
}
return { value: undefined, done: true };
}
}
async function processRealtimeMarketData() {
// Example: Imagine a global market data WebSocket feed
const marketDataFeed = new WebSocketDataFeed('wss://marketdata.example.com/live');
let totalTrades = 0;
console.log('Connecting to real-time market data feed...');
try {
for await (const trade of marketDataFeed) {
totalTrades++;
console.log(`New Trade: ${trade.symbol}, Price: ${trade.price}, Volume: ${trade.volume}`);
if (totalTrades >= 10) {
console.log('Processed 10 trades. Stopping for demonstration.');
break; // Stop iteration, triggering marketDataFeed.return()
}
// Simulate some asynchronous processing of the trade data
await new Promise(resolve => setTimeout(resolve, 100));
}
} catch (error) {
console.error('Error processing market data:', error);
} finally {
console.log(`Total trades processed: ${totalTrades}`);
}
}
// To run (in a browser environment or Node.js with a WebSocket library):
// processRealtimeMarketData();
இந்தத் தனிப்பயன் async iterator, ஒரு நிகழ்வு-உந்தப்பட்ட தரவு மூலத்தை (WebSocket போன்றது) ஒரு async iterable இல் எவ்வாறு மடக்குவது என்பதைக் காட்டுகிறது, இதனால் அதை for await...of உடன் பயன்படுத்த முடியும். இது பஃபரிங் மற்றும் புதிய தரவுக்காகக் காத்திருப்பதைக் கையாள்கிறது, வெளிப்படையான பின் அழுத்தக் கட்டுப்பாடு மற்றும் return() வழியாக வளச் சுத்திகரிப்பைக் காட்டுகிறது. இந்த முறை நிகழ்நேர பயன்பாடுகளுக்கு நம்பமுடியாத அளவிற்கு சக்தி வாய்ந்தது, உதாரணமாக நேரடி டாஷ்போர்டுகள், கண்காணிப்பு அமைப்புகள் அல்லது உலகத்தின் எந்த மூலையிலிருந்தும் உருவாகும் தொடர்ச்சியான நிகழ்வு ஸ்ட்ரீம்களைச் செயலாக்க வேண்டிய தகவல் தொடர்பு தளங்கள் போன்றவற்றுக்கு இது பயனுள்ளதாக இருக்கும்.
மேம்பட்ட மேம்படுத்தல் நுட்பங்கள்
அடிப்படைப் பயன்பாடு கணிசமான நன்மைகளை வழங்கினாலும், மேலும் மேம்படுத்தல்கள் சிக்கலான ஸ்ட்ரீம் செயலாக்க சூழ்நிலைகளுக்கு இன்னும் சிறந்த செயல்திறனை வெளிப்படுத்தும்.
1. Async Iterators மற்றும் குழாய்களை ஒருங்கிணைத்தல்
ஒத்திசைவான iterators போலவே, async iterators ஐ சக்திவாய்ந்த தரவு செயலாக்க குழாய்களை உருவாக்க ஒன்றிணைக்க முடியும். குழாயின் ஒவ்வொரு நிலையும் முந்தைய நிலையிலிருந்து தரவை மாற்றியமைக்கும் அல்லது வடிகட்டும் ஒரு async generator ஆக இருக்கலாம்.
// A generator that simulates fetching raw data
async function* fetchDataStream() {
const data = [
{ id: 1, tempC: 25, location: 'Tokyo' },
{ id: 2, tempC: 18, location: 'London' },
{ id: 3, tempC: 30, location: 'Dubai' },
{ id: 4, tempC: 22, location: 'New York' },
{ id: 5, tempC: 10, location: 'Moscow' }
];
for (const item of data) {
await new Promise(resolve => setTimeout(resolve, 50)); // Simulate async fetch
yield item;
}
}
// A transformer that converts Celsius to Fahrenheit
async function* convertToFahrenheit(source) {
for await (const item of source) {
const tempF = (item.tempC * 9/5) + 32;
yield { ...item, tempF };
}
}
// A filter that selects data from warmer locations
async function* filterWarmLocations(source, thresholdC) {
for await (const item of source) {
if (item.tempC > thresholdC) {
yield item;
}
}
}
async function processSensorDataPipeline() {
const rawData = fetchDataStream();
const fahrenheitData = convertToFahrenheit(rawData);
const warmFilteredData = filterWarmLocations(fahrenheitData, 20); // Filter > 20C
console.log('Processing sensor data pipeline:');
for await (const processedItem of warmFilteredData) {
console.log(`Location: ${processedItem.location}, Temp C: ${processedItem.tempC}, Temp F: ${processedItem.tempF}`);
}
console.log('Pipeline complete.');
}
// To run:
// processSensorDataPipeline();
Node.js ஆனது stream/promises தொகுதியையும் pipeline() உடன் வழங்குகிறது, இது Node.js ஸ்ட்ரீம்களை ஒன்றிணைக்க ஒரு வலுவான வழியை வழங்குகிறது, இது பெரும்பாலும் async iterators ஆக மாற்றப்படக்கூடியது. இந்த மட்டுத்தன்மை, வெவ்வேறு பிராந்திய தரவு செயலாக்கத் தேவைகளுக்கு ஏற்ப மாற்றக்கூடிய சிக்கலான, பராமரிக்கக்கூடிய தரவு ஓட்டங்களை உருவாக்குவதற்கு சிறந்தது.
2. செயல்பாடுகளை இணைகோடாக்குதல் (எச்சரிக்கையுடன்)
for await...of தொடர்ச்சியானதாக இருந்தாலும், ஒரு iterator இன் next() முறைக்குள் ஒரே நேரத்தில் பல உருப்படிகளைப் பெறுவதன் மூலம் அல்லது உருப்படிகளின் தொகுதிகளில் Promise.all() போன்ற கருவிகளைப் பயன்படுத்துவதன் மூலம் ஒரு குறிப்பிட்ட அளவு இணைகோடியை அறிமுகப்படுத்தலாம்.
async function* parallelFetchPages(baseUrl, initialParams = {}, concurrency = 3) {
let currentPage = 1;
let hasMore = true;
const fetchPage = async (pageNumber) => {
const params = new URLSearchParams({ ...initialParams, page: pageNumber });
const url = `${baseUrl}?${params.toString()}`;
console.log(`Initiating fetch for page ${pageNumber} from ${url}`);
const response = await fetch(url);
if (!response.ok) {
throw new Error(`API error on page ${pageNumber}: ${response.statusText}`);
}
return response.json();
};
let pendingFetches = [];
// Start with initial fetches up to concurrency limit
for (let i = 0; i < concurrency && hasMore; i++) {
pendingFetches.push(fetchPage(currentPage++));
if (currentPage > 5) hasMore = false; // Simulate limited pages for demo
}
while (pendingFetches.length > 0) {
const { resolved, index } = await Promise.race(
pendingFetches.map((p, i) => p.then(data => ({ resolved: data, index: i })))
);
// Process items from the resolved page
for (const item of resolved.items) {
yield item;
}
// Remove resolved promise and potentially add a new one
pendingFetches.splice(index, 1);
if (hasMore) {
pendingFetches.push(fetchPage(currentPage++));
if (currentPage > 5) hasMore = false; // Simulate limited pages for demo
}
}
}
async function processHighVolumeAPIData() {
const apiEndpoint = "https://api.example.com/high-volume-data";
console.log('Processing high-volume API data with limited concurrency...');
try {
for await (const item of parallelFetchPages(apiEndpoint, {}, 3)) {
console.log(`Processed item: ${JSON.stringify(item)}`);
// Simulate heavy processing
await new Promise(resolve => setTimeout(resolve, 200));
}
console.log('High-volume API data processing complete.');
} catch (error) {
console.error(`Error in high-volume API data processing: ${error.message}`);
}
}
// To run:
// processHighVolumeAPIData();
இந்த எடுத்துக்காட்டு, ஒரே நேரத்தில் கோரிக்கைகளின் தொகுப்பைக் கையாள Promise.race ஐப் பயன்படுத்துகிறது, ஒரு பக்கம் முடிந்தவுடன் அடுத்த பக்கத்தைப் பெறுகிறது. இது அதிக தாமதமுள்ள உலகளாவிய APIகளிலிருந்து தரவு உள்ளீட்டை கணிசமாக விரைவுபடுத்தலாம், ஆனால் API சேவையகம் அல்லது உங்கள் சொந்த பயன்பாட்டின் வளங்களை அதிக சுமையாகப் பயன்படுத்துவதைத் தவிர்க்க, இணக்கத்தன்மை வரம்பை கவனமாக நிர்வகிக்க வேண்டும்.
3. தொகுதி செயல்பாடுகள்
சில நேரங்களில், உருப்படிகளை தனித்தனியாகச் செயலாக்குவது திறனற்றது, குறிப்பாக வெளிப்புற அமைப்புகளுடன் (எ.கா., தரவுத்தள எழுதுதல், ஒரு வரிசைக்கு செய்திகளை அனுப்புதல், மொத்த API அழைப்புகளைச் செய்தல்) தொடர்பு கொள்ளும்போது. Async iterators ஐப் பயன்படுத்தி உருப்படிகளைச் செயலாக்குவதற்கு முன் தொகுதியாக்கலாம்.
async function* batchItems(source, batchSize) {
let batch = [];
for await (const item of source) {
batch.push(item);
if (batch.length >= batchSize) {
yield batch;
batch = [];
}
}
if (batch.length > 0) {
yield batch;
}
}
async function processBatchedUpdates(dataStream) {
console.log('Processing data in batches for efficient writes...');
for await (const batch of batchItems(dataStream, 5)) {
console.log(`Processing batch of ${batch.length} items: ${JSON.stringify(batch.map(i => i.id))}`);
// Simulate a bulk database write or API call
await new Promise(resolve => setTimeout(resolve, 500));
}
console.log('Batch processing complete.');
}
// Dummy data stream for demonstration
async function* dummyItemStream() {
for (let i = 1; i <= 12; i++) {
await new Promise(resolve => setTimeout(resolve, 10));
yield { id: i, value: `data_${i}` };
}
}
// To run:
// processBatchedUpdates(dummyItemStream());
தொகுதியாக்குதல், I/O செயல்பாடுகளின் எண்ணிக்கையைக் கணிசமாகக் குறைக்கும், Apache Kafka போன்ற ஒரு விநியோகிக்கப்பட்ட வரிசைக்கு செய்திகளை அனுப்புதல் அல்லது உலகளவில் படியெடுக்கப்பட்ட தரவுத்தளத்தில் மொத்தமாகச் செருகுதல் போன்ற செயல்பாடுகளின் செயல்திறனை மேம்படுத்தும்.
4. வலுவான பிழை கையாளுதல்
எந்தவொரு உற்பத்தி அமைப்புக்கும் பயனுள்ள பிழை கையாளுதல் முக்கியமானது. Async iterators, நுகர்வோர் சுழற்சிக்குள் ஏற்படும் பிழைகளுக்கான நிலையான try...catch தொகுதிகளுடன் நன்றாக ஒருங்கிணைக்கின்றன. கூடுதலாக, தயாரிப்பாளர் (async iterator தானாகவே) பிழைகளை வீசலாம், அவை நுகர்வோரால் பிடிக்கப்படும்.
async function* unreliableDataSource() {
for (let i = 0; i < 5; i++) {
await new Promise(resolve => setTimeout(resolve, 100));
if (i === 2) {
throw new Error('Simulated data source error at item 2');
}
yield i;
}
}
async function consumeUnreliableData() {
console.log('Attempting to consume unreliable data...');
try {
for await (const data of unreliableDataSource()) {
console.log(`Received data: ${data}`);
}
} catch (error) {
console.error(`Caught error from data source: ${error.message}`);
// Implement retry logic, fallback, or alert mechanisms here
} finally {
console.log('Unreliable data consumption attempt finished.');
}
}
// To run:
// consumeUnreliableData();
இந்த அணுகுமுறை, மையப்படுத்தப்பட்ட பிழை கையாளுதலை அனுமதிக்கிறது மற்றும் மீண்டும் முயற்சிக்கும் வழிமுறைகள் அல்லது சர்க்யூட் பிரேக்கர்களைச் செயல்படுத்துவதை எளிதாக்குகிறது, இது பல தரவு மையங்கள் அல்லது கிளவுட் பிராந்தியங்களை உள்ளடக்கிய விநியோகிக்கப்பட்ட அமைப்புகளில் பொதுவான நிலையற்ற தோல்விகளைக் கையாள்வதற்கு அத்தியாவசியமானது.
செயல்திறன் பரிசீலனைகள் மற்றும் அளவுகோலிடுதல்
async iterators ஸ்ட்ரீம் செயலாக்கத்திற்கான குறிப்பிடத்தக்க கட்டடக்கலை நன்மைகளை வழங்கினாலும், அவற்றின் செயல்திறன் பண்புகளைப் புரிந்துகொள்வது முக்கியம்:
- கூடுதல் செலவு: Promiseகள் மற்றும்
async/awaitதொடரியலுடன் தொடர்புடைய ஒரு உள்ளார்ந்த கூடுதல் செலவு, raw callbacks அல்லது அதிக உகந்த நிகழ்வு எமிட்டர்களுடன் ஒப்பிடும்போது உள்ளது. மிக அதிக அலைவரிசை, குறைந்த தாமதம் கொண்ட மிகச் சிறிய தரவுத் துண்டுகளுடன் கூடிய சூழ்நிலைகளுக்கு, இந்த கூடுதல் செலவு அளவிடக்கூடியதாக இருக்கலாம். - சூழல் மாறுதல்: ஒவ்வொரு
awaitஉம் நிகழ்வு சுழலில் ஒரு சாத்தியமான சூழல் மாற்றத்தைக் குறிக்கிறது. தடையற்றதாக இருந்தாலும், அற்பமான பணிகளுக்கான அடிக்கடி சூழல் மாறுதல் அதிகமாக இருக்கலாம். - எப்போது பயன்படுத்த வேண்டும்: I/O-சார்ந்த செயல்பாடுகள் (நெட்வொர்க், டிஸ்க்) அல்லது தரவு காலப்போக்கில் இயல்பாகவே கிடைக்கும் செயல்பாடுகளைக் கையாளும் போது Async iterators பிரகாசிக்கின்றன. அவை raw CPU வேகத்தைப் பற்றியது குறைவு, மாறாக திறமையான வள மேலாண்மை மற்றும் பதிலளிப்புத்தன்மை பற்றியது அதிகம்.
அளவுகோலிடுதல்: உங்கள் குறிப்பிட்ட பயன்பாட்டு வழக்கத்தை எப்போதும் அளவுகோலிடுங்கள். செயல்திறனைப் பார்க்க Node.js இன் உள்ளமைக்கப்பட்ட perf_hooks தொகுதி அல்லது உலாவி டெவலப்பர் கருவிகளைப் பயன்படுத்தவும். உண்மையான உலக நன்மைகளை (பின் அழுத்தம் கையாளுதல் போன்றவை) பிரதிபலிக்காத மைக்ரோ-அளவுகோலிகளுக்குப் பதிலாக, உண்மையான பயன்பாட்டு அலைவரிசை, நினைவகப் பயன்பாடு மற்றும் யதார்த்தமான சுமை நிலைமைகளின் கீழ் தாமதம் ஆகியவற்றில் கவனம் செலுத்துங்கள்.
உலகளாவிய தாக்கம் மற்றும் எதிர்கால போக்குகள்
"JavaScript Async Iterator செயல்திறன் எஞ்சின்" என்பது ஒரு மொழி அம்சம் மட்டுமல்ல; தகவல்களால் நிறைந்த உலகில் தரவு செயலாக்கத்தை அணுகும் விதத்தில் இது ஒரு பெரிய மாற்றமாகும்.
- மைக்ரோசேவைகள் மற்றும் சர்வர்லெஸ்: நிகழ்வு ஸ்ட்ரீம்கள் வழியாகத் தொடர்பு கொள்ளும் அல்லது பெரிய பேலோடுகளை ஒத்திசைவற்ற முறையில் செயலாக்கும் வலுவான மற்றும் அளவிடக்கூடிய மைக்ரோசேவைகளை உருவாக்குவதை Async iterators எளிதாக்குகின்றன. சர்வர்லெஸ் சூழல்களில், அவை தற்காலிக நினைவக வரம்புகளைச் சோர்வடையச் செய்யாமல் பெரிய தரவுத் தொகுதிகளை திறமையாகக் கையாளும் செயல்பாடுகளை செயல்படுத்துகின்றன.
- IoT தரவு ஒருங்கிணைப்பு: உலகளவில் பயன்படுத்தப்படும் மில்லியன் கணக்கான IoT சாதனங்களிலிருந்து தரவுகளை ஒருங்கிணைப்பதற்கும் செயலாக்குவதற்கும், தொடர்ச்சியான சென்சார் அளவீடுகளை உள்ளீடு செய்வதற்கும் வடிகட்டுவதற்கும் async iterators ஒரு இயற்கையான பொருத்தத்தை வழங்குகின்றன.
- AI/ML தரவு குழாய்கள்: இயந்திர கற்றல் மாதிரிகளுக்கான பெரிய தரவுத்தொகுப்புகளைத் தயாரிப்பது மற்றும் ஊட்டுவது பெரும்பாலும் சிக்கலான ETL செயல்முறைகளை உள்ளடக்கியது. Async iterators இந்த குழாய்களை நினைவக-திறமையான முறையில் ஒழுங்குபடுத்த முடியும்.
- WebRTC மற்றும் நிகழ்நேர தொடர்பு: நேரடியாக async iterators ஐ அடிப்படையாகக் கொண்டிருக்கவில்லை என்றாலும், ஸ்ட்ரீம் செயலாக்கம் மற்றும் ஒத்திசைவற்ற தரவு ஓட்டத்தின் அடிப்படைக் கருத்துக்கள் WebRTC க்கு அடித்தளமாக உள்ளன, மேலும் தனிப்பயன் async iterators நிகழ்நேர ஆடியோ/வீடியோ துண்டுகளைச் செயலாக்குவதற்கான அடாப்டர்களாகச் செயல்படலாம்.
- இணைய தரநிலைகளின் பரிணாம வளர்ச்சி: Node.js மற்றும் உலாவிகளில் async iterators இன் வெற்றி புதிய இணைய தரநிலைகளைத் தொடர்ந்து பாதிக்கிறது, ஒத்திசைவற்ற, ஸ்ட்ரீம் அடிப்படையிலான தரவு கையாளுதலுக்கு முன்னுரிமை அளிக்கும் வடிவங்களை ஊக்குவிக்கிறது.
By adopting async iterators, developers can build applications that are not only faster and more reliable but also inherently better equipped to handle the dynamic and geographically distributed nature of modern data.
முடிவுரை: தரவு ஸ்ட்ரீம்களின் எதிர்காலத்திற்கு சக்தி அளித்தல்
JavaScript இன் ஒத்திசைவற்ற Iterators, ஒரு 'செயல்திறன் எஞ்சினாக' புரிந்து கொள்ளப்பட்டு பயன்படுத்தப்படும்போது, நவீன டெவலப்பர்களுக்கு ஒரு அத்தியாவசிய கருவித்தொகுப்பை வழங்குகின்றன. அவை தரவு ஸ்ட்ரீம்களை நிர்வகிப்பதற்கான ஒரு தரப்படுத்தப்பட்ட, நேர்த்தியான மற்றும் மிகவும் திறமையான வழியை வழங்குகின்றன, தரவு அளவுகள் மற்றும் உலகளாவிய விநியோகச் சிக்கல்கள் அதிகரித்து வரும் முகப்பில் பயன்பாடுகள் செயல்திறன் மிக்கதாகவும், பதிலளிக்கக்கூடியதாகவும், நினைவக விழிப்புணர்வுடனும் இருப்பதை உறுதி செய்கின்றன.
சோம்பேறி மதிப்பீடு, மறைமுக பின் அழுத்தம் மற்றும் புத்திசாலித்தனமான வள மேலாண்மையை ஏற்றுக்கொள்வதன் மூலம், நீங்கள் உள்ளூர் கோப்புகளிலிருந்து கண்டம் தழுவிய தரவு ஊட்டங்கள் வரை எளிதாக அளவிடக்கூடிய அமைப்புகளை உருவாக்கலாம், இது ஒரு காலத்தில் சிக்கலான சவாலாக இருந்ததை ஒரு நெறிப்படுத்தப்பட்ட, மேம்படுத்தப்பட்ட செயல்முறையாக மாற்றுகிறது. இப்போதே async iterators உடன் பரிசோதனை செய்யத் தொடங்குங்கள் மற்றும் உங்கள் JavaScript பயன்பாடுகளில் புதிய செயல்திறன் மற்றும் மீள்தன்மையை திறக்கவும்.